/*
srkrt_disp_gui_callbacks.c
Ce fichier contient le corps des fonctions callbacks utilisées pour l'interface.
*/
#include "srkrt_disp_gui_callbacks.h"
#include "srkrt_ia.h"
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>


#ifdef WIN32 /* Windows */
#include "windows.h"
#else /* Unix et autres */
#include "unistd.h"
#endif

void disp_gtk_init(GtkWidget* fixed, GtkWidget* table, Global* global) {

	int i,j;
	char chaineColonne[] = "<b>1</b>"; /* <b> = bold, la numerotation se fait a partir de en bas a gauche */
	char chaineLigne[] = "<b>F</b>"; 
	GtkWidget *colonne[6], *ligne[6];
	
	/* initialisation a NULL */
	for ( i = 0 ; i < 6 ; i++ ) {
		for ( j = 0 ; j < 6 ; j++ ) {
			global->grille[i][j].eventBox = NULL;
			global->grille[i][j].image = NULL;
		}
	}

	/* on crée la table */
	table = gtk_table_new(8, 7, TRUE);
    
	
    
	/* on créé le marquage des lignes et colonnes*/
		for ( i = 0 ; i < 6 ; i++ ) {
			colonne[i] = gtk_label_new(chaineColonne);
			ligne[i] = gtk_label_new(chaineLigne);
			/* on initialise l'utilisation des balises pour mettre en bold */
			gtk_label_set_use_markup(GTK_LABEL(colonne[i]), TRUE);
			gtk_label_set_use_markup(GTK_LABEL(ligne[i]), TRUE);
			chaineColonne[3]++;
			chaineLigne[3]--;
			/* je met le widget dans la table. il faut donne le coin superieur gauche et inferieur droit.*/
			gtk_table_attach_defaults(GTK_TABLE(table), colonne[i], i+1, i+2, 7, 8); /* x gauche, x droit, yhaut, ybas*/
			gtk_table_attach_defaults(GTK_TABLE(table), ligne[i], 0, 1, i+1, i+2);
		}
		
	/* ajout des eventBox pour rendre les cases cliquables */
	for ( i = 0 ; i < 6 ; i++ ) {
		for ( j = 0 ; j < 6 ; j++ ) {
			
			global->grille[i][j].eventBox = gtk_event_box_new();
			/* on rend la zone cliquable invisible*/
			gtk_event_box_set_visible_window(GTK_EVENT_BOX(global->grille[i][j].eventBox), false);

			/* on l'attache */
			gtk_table_attach_defaults (GTK_TABLE(table), global->grille[i][j].eventBox, j+1, j+2, i+1, i+2);
	
			/* On ajoute le signal "button_press_event" au GtkEventBox.*/
			g_signal_connect(G_OBJECT(global->grille[i][j].eventBox), "button_press_event", G_CALLBACK(disp_gtk_on_press_square), global);
		}
	}
	
	/* initialisation de l'affichage des pions */
	disp_gtk_reset(global);

	/* on met la table dans le fixed */
	gtk_fixed_put(GTK_FIXED(fixed), table, 55, 55);
}

void disp_gtk_on_change_pawns(GtkWidget* widget, Global* global) {
	const gchar* radioName;
	int i,j;
	
	/* recuperation du nom du radio selectionne */
	radioName = gtk_label_get_label(GTK_LABEL(GTK_BIN(widget)->child));

	if ( !strcmp(radioName, "wood") ) {
    sprintf(global->pawnPlayer1, "%s%s", IMAGES_PATH, "/pion2.png");
    sprintf(global->pawnPlayer1Highlight, "%s%s", IMAGES_PATH, "/pion2_highlight.png");
    sprintf(global->pawnPlayer2, "%s%s", IMAGES_PATH, "/pion3.png");
    sprintf(global->pawnPlayer2Highlight, "%s%s", IMAGES_PATH, "/pion3_highlight.png");

	} else if ( !strcmp(radioName, "pion2") ) {
    sprintf(global->pawnPlayer1, "%s%s", IMAGES_PATH, "/pion1.png");
    sprintf(global->pawnPlayer1Highlight, "%s%s", IMAGES_PATH, "/pion1_highlight.png");
    sprintf(global->pawnPlayer2, "%s%s", IMAGES_PATH, "/pion0.png");
    sprintf(global->pawnPlayer2Highlight, "%s%s", IMAGES_PATH, "/pion0_highlight.png");

	} else {
		fprintf(stderr, "Error in disp_gtk_on_change_pawns() : unmatched value !\n");
	}

	for ( i = 0 ; i < 6 ; i++ ) {
		for ( j = 0 ; j < 6 ; j++ ) {
			/* modification des images des pions des 2 joueurs */
			if ( global->game.board[i][j] == PLAYER_1 ) {
				gtk_image_set_from_file(GTK_IMAGE(global->grille[i][j].image), global->pawnPlayer1);
			} else if ( global->game.board[i][j] == PLAYER_2 ) {
				gtk_image_set_from_file(GTK_IMAGE(global->grille[i][j].image), global->pawnPlayer2);
			}
		}
	}
}

void disp_gtk_on_change_background(GtkWidget* widget, Global* global) {

	const gchar* radioName;

	/* recuperation du nom du radio selectionne */
	radioName = gtk_label_get_label(GTK_LABEL(GTK_BIN(widget)->child));

	if ( !strcmp(radioName, "desert") ) {
    sprintf(global->background, "%s%s", IMAGES_PATH, "/fond1.jpg");
	} else if ( !strcmp(radioName, "elephant") ) {
    sprintf(global->background, "%s%s", IMAGES_PATH, "/fond2.jpg");
	} else {
		fprintf(stderr, "Error in disp_gtk_on_change_background() : unmatched value !\n");
	}

	/* changement de l'image de fond */
	gtk_image_set_from_file(GTK_IMAGE(global->imageBackground), global->background);
}

void disp_gtk_on_change_level(GtkWidget* widget, Global* global) {
	const gchar *RadioName;

	/* recuperation le label du bouton radio selectionne */
	RadioName = gtk_label_get_label(GTK_LABEL(GTK_BIN(widget)->child));

	if ( !strcmp(RadioName, "facile") ) {
		global->game.level = LEVEL_EASY;
	} else if ( !strcmp(RadioName, "moyen") ) {
		global->game.level = LEVEL_MEDIUM;
	} else {
		global->game.level = LEVEL_HARD;
	}
}

void disp_gtk_on_new(GtkWidget* widget, Global* global) {
	GtkWidget* pBox;
	GtkWidget *HBoxType, *HBoxLevel, *HBoxWho;
	GtkWidget *radioType1, *radioType2;
	GtkWidget *radioLevel1, *radioLevel2, *radioLevel3;
	GtkWidget *radioWho1, *radioWho2;
	GtkWidget *labelType, *labelLevel, *labelWho;
	#ifdef NETWORK
	GtkWidget *radioType3;
	#endif
	int vs, level;
	
	/* Creation de la boite de dialogue */
	pBox = gtk_dialog_new_with_buttons("Commencez une nouvelle partie",
						GTK_WINDOW(global->mainWindow),
						GTK_DIALOG_MODAL,
						GTK_STOCK_OK,GTK_RESPONSE_OK,
						GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,
						NULL);
						
	
	/* Pour le type de la partie */
	HBoxType = gtk_hbox_new(TRUE, 0);
	
	labelType = gtk_label_new("Choisissez le type de la partie");
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBox)->vbox), labelType, FALSE, FALSE, 0);
	
	radioType1 = gtk_radio_button_new_with_label(NULL, "Humain vs Humain");
	gtk_box_pack_start(GTK_BOX(HBoxType), radioType1, FALSE, FALSE, 0);
	radioType2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (radioType1), "Humain vs Ordinateur");
	gtk_box_pack_start(GTK_BOX(HBoxType), radioType2, FALSE, FALSE, 0);
	#ifdef NETWORK
	radioType3 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (radioType1), "Humain vs Humain en Réseaux");
	gtk_box_pack_start(GTK_BOX(HBoxType), radioType3, FALSE, FALSE, 0);
	#endif
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBox)->vbox), HBoxType, FALSE, FALSE, 0);
	
	/* Pour le niveau de la partie  */
	HBoxLevel = gtk_hbox_new(TRUE, 0);
	
	labelLevel = gtk_label_new("Choisissez le niveau de l'adversaire");
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBox)->vbox), labelLevel, FALSE, FALSE, 0);
	
	radioLevel1 = gtk_radio_button_new_with_label(NULL, "FACILE");
	gtk_box_pack_start(GTK_BOX(HBoxLevel), radioLevel1, FALSE, FALSE, 0);
	radioLevel2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (radioLevel1), "MOYEN");
	gtk_box_pack_start(GTK_BOX(HBoxLevel), radioLevel2, FALSE, FALSE, 0);
	radioLevel3 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (radioLevel1), "DIFFICILE");
	gtk_box_pack_start(GTK_BOX(HBoxLevel), radioLevel3, FALSE, FALSE, 0);
	
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBox)->vbox), HBoxLevel, FALSE, FALSE, 0);
	
	/* Pour le joueur qui commence la partie */
	HBoxWho = gtk_hbox_new(TRUE, 0);
	
	labelWho = gtk_label_new("Choisissez qui commence la partie");
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBox)->vbox), labelWho, FALSE, FALSE, 0);
	
	radioWho1 = gtk_radio_button_new_with_label(NULL, "Joueur 1");
	gtk_box_pack_start(GTK_BOX(HBoxWho), radioWho1, FALSE, FALSE, 0);
	radioWho2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (radioWho1), "Joueur 2");
	gtk_box_pack_start(GTK_BOX(HBoxWho), radioWho2, FALSE, FALSE, 0);
	
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBox)->vbox), HBoxWho, FALSE, FALSE, 0);
				
	/* Affichage des elements de la boite de dialogue */
	gtk_widget_show_all(GTK_DIALOG(pBox)->vbox);

	/* On lance la boite de dialogue et on recupere la reponse */
	switch (gtk_dialog_run(GTK_DIALOG(pBox)))
	{
		/* L utilisateur valide */
		case GTK_RESPONSE_OK:
			/* on analyse le type de la partie */
			if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radioType1))) {
				/* c'est une partie Human vs Human */
				vs = HUMAN;
			} else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radioType2))) {
				/* c'est une partie Human vs CPU */
				vs = CPU;
				/* on analyse le niveau */
				if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radioLevel1))) {
					/* niveau facile */
					level = LEVEL_EASY;
				} else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radioLevel1))) {
					/* niveau moyen */
					level = LEVEL_MEDIUM;
				} else {
					/* niveau difficile */
					level = LEVEL_HARD;
				}
			} else {
				vs = ON_LINE;
			}
			/* on analyse qui commence */
			if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radioWho1))) {
				/* c'est le joueur 1 qui commance */
				global->game.toPlay = PLAYER_1;
			} else {
				/* c'est le joueur 2 qui commence */
				global->game.toPlay = PLAYER_2;
			}
			break;
		/* L utilisateur annule */
		case GTK_RESPONSE_CANCEL:
			gtk_widget_destroy(pBox);
			return;
		default:
			gtk_widget_destroy(pBox);
			return;
	}
	/* creation de la nouvelle partie */
	
	/* suppression de l'historique*/
	stack_destroy(&(global->game.history));
	global->game = srkrt_create(global->game.toPlay);
	global->game.vs = vs ;
	global->game.level = level ;
	
	global->choice = 1 ;
	disp_gtk_reset(global);
	
	if ( (global->game.vs == CPU) && (global->game.toPlay == PLAYER_2) ) {
		/* si l'ordinateur doit commencer, il joue */
		disp_gtk_cpu_play(global) ;
	}
	#ifdef NETWORK
	/* envoie d'une message de "nouvelle partie" via ivy */
	IvySendMsg("NewGame: %d", global->game.toPlay);
	#endif
	/* Destruction de la boite de dialogue */
	gtk_widget_destroy(pBox);
}

void disp_gtk_highlight_pawn(Global* global) {
	/* on surligne un pion */
	if ( global->choice == 1 ) {
		/* si c'est un pion du joueur 1 */
		if ( (global->game.toPlay == PLAYER_1) && (global->game.board[global->move.xi][global->move.yi] == PLAYER_1) ) {
			gtk_image_set_from_file(GTK_IMAGE(global->grille[global->move.xi][global->move.yi].image), global->pawnPlayer1Highlight);
		/* si c'est un pion du joueur 2 */
		} else if ((global->game.toPlay == PLAYER_2) && (global->game.board[global->move.xi][global->move.yi] == PLAYER_2) ) {
			gtk_image_set_from_file(GTK_IMAGE(global->grille[global->move.xi][global->move.yi].image), global->pawnPlayer2Highlight);
		}
	} else if ( global->choice == 2 ) { /* on de-surligne un pion */
		/*si c'est un pion du joueur 1*/
		if ( (global->game.toPlay == PLAYER_1) && (global->game.board[global->move.xi][global->move.yi] == PLAYER_1) ) {
			gtk_image_set_from_file(GTK_IMAGE(global->grille[global->move.xi][global->move.yi].image), global->pawnPlayer1);
		/* si c'est un pion du joueur 2 */
		} else if ((global->game.toPlay == PLAYER_2) && (global->game.board[global->move.xi][global->move.yi] == PLAYER_2) ) {
			gtk_image_set_from_file(GTK_IMAGE(global->grille[global->move.xi][global->move.yi].image), global->pawnPlayer2);
		}
	} else {
		fprintf(stderr, "Erreur in disp_gtk_highlight_pawn() : unmatched value !\n");
	}
}

void disp_gtk_reset(Global* global) {

	int i,j;
	
	/* on positionne les pions */
	for ( i = 0 ; i < 2 ; i++ ) {
		for ( j = 0 ; j < 6 ; j++ ) {
			/* pion de l'ordinateur */
			/* on vérifie si la case n'a pas ete initialisé */
			if ( global->grille[i][j].image != NULL ) {
				/* on change l'image */
				gtk_image_set_from_file(GTK_IMAGE(global->grille[i][j].image), global->pawnPlayer2);	
			} else {
				/* on cree l'image */
				global->grille[i][j].image = gtk_image_new_from_file(global->pawnPlayer2);
				/* on ajoute le contener */
				gtk_container_add(GTK_CONTAINER(global->grille[i][j].eventBox), global->grille[i][j].image);	
			}

			/* pion du joueur */
			if ( global->grille[5-i][j].image != NULL ) {
				/* on change l'image */
				gtk_image_set_from_file(GTK_IMAGE(global->grille[5-i][j].image), global->pawnPlayer1);
			} else {
				/* on cree l'image */
				global->grille[5-i][j].image = gtk_image_new_from_file(global->pawnPlayer1);
				/* on ajoute le contener */
				gtk_container_add(GTK_CONTAINER(global->grille[5-i][j].eventBox), global->grille[5-i][j].image);	
			}
			gtk_widget_show(global->grille[i][j].image);
			gtk_widget_show(global->grille[5-i][j].image);
			
			
			/* case centrale : on cache les images presentes */
			if ( global->grille[3-i][j].image != NULL ) {
				/*gtk_widget_destroy(global->grille[3-i][j].image);*/
				gtk_widget_hide(global->grille[3-i][j].image);
			}
		}
	}
}

void disp_gtk_on_change_value(GtkWidget* widget, gpointer data) {

	gchar* sLabel;
	gdouble value;

	/* Recuperation de la valeur de la scrollbar */
	value = gtk_range_get_value(GTK_RANGE(widget));
	/* Creation du nouveau label */
	sLabel = g_strdup_printf("%d", (int)value);
	/* Modification du label */
	gtk_label_set_text(GTK_LABEL(data), sLabel);
	/* Liberation memoire */
	g_free(sLabel);
}

void disp_gtk_on_cancel(GtkWidget* widget, Global* global) {

	GtkWidget* pBox;
	GtkObject* adjustment;
	GtkWidget* selectValue;
	GtkWidget* label;
	gdouble value;
	Move m;
	
	
	
	/* Creation de la boite de dialogue */
	/* 1 bouton Valider */
	/* 1 bouton Annuler */
	pBox = gtk_dialog_new_with_buttons("Choisissez le nombre de coup à annuler",
					      GTK_WINDOW(global->mainWindow),
					      GTK_DIALOG_MODAL,
					      GTK_STOCK_OK,GTK_RESPONSE_OK,
					      GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,
					      NULL);
					      
	/* Creation de la zone de saisie */
	adjustment = gtk_adjustment_new (0, 0, stack_size(&(global->game.history))+1, 2, 6, 1);
	selectValue = gtk_hscrollbar_new(GTK_ADJUSTMENT(adjustment));
	label = gtk_label_new("0");
	/* Insertion de la zone de saisie dans la boite de dialogue */
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBox)->vbox), selectValue, TRUE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBox)->vbox), label, TRUE, FALSE, 0);
	
	
	/* connexion des signaux */
	g_signal_connect(G_OBJECT(selectValue), "value-changed", G_CALLBACK(disp_gtk_on_change_value), (GtkWidget*)label);
			  
	/* Affichage des elements de la boite de dialogue */
	gtk_widget_show_all(GTK_DIALOG(pBox)->vbox);
	
	/* On lance la boite de dialogue et on recupere la reponse */
	switch (gtk_dialog_run(GTK_DIALOG(pBox)))
	{
		/* L utilisateur valide */
		case GTK_RESPONSE_OK:
			/* recuperation du nombre de coups à annuler */
			value = gtk_range_get_value(GTK_RANGE(selectValue));
			fprintf(stderr, "%d", (int)value);
			break;
		/* L utilisateur annule */
		case GTK_RESPONSE_CANCEL:
			gtk_widget_destroy(pBox);
			return;
		default:
			gtk_widget_destroy(pBox);
			return;
				break;
	}
	
	/* annulation des coups */
	while ( value > 0 ) {
		/* on recupere le coup a annuler */
		m = stack_head(&(global->game.history));
		/* on annule le coup */
		srkrt_take_back(&(global->game));
		fprintf(stderr, "\n%d", (int)value);

		/* si il y a eu une prise, on affiche la case d'origine */
			if ( global->game.toPlay == PLAYER_1 ) {
				if ( m.capture ) {
					gtk_image_set_from_file(GTK_IMAGE(global->grille[m.xf][m.yf].image), global->pawnPlayer2);
					gtk_widget_show(global->grille[m.xf][m.yf].image);
				} else {
					gtk_widget_hide(global->grille[m.xf][m.yf].image);
				}
				gtk_image_set_from_file(GTK_IMAGE(global->grille[m.xi][m.yi].image), global->pawnPlayer1);
				
			} else {
				if ( m.capture ) {
					gtk_image_set_from_file(GTK_IMAGE(global->grille[m.xf][m.yf].image), global->pawnPlayer1);
					gtk_widget_show(global->grille[m.xf][m.yf].image);
				} else {
					gtk_widget_hide(global->grille[m.xf][m.yf].image);
				}
				gtk_image_set_from_file(GTK_IMAGE(global->grille[m.xi][m.yi].image), global->pawnPlayer2);	
			}
			
			gtk_widget_show(global->grille[m.xi][m.yi].image);
		value--;	
	}
	/* Destruction de la boite de dialogue */
	gtk_widget_destroy(pBox);    
}

void disp_gtk_on_save(GtkWidget* widget, Global* global) {

	GtkWidget* pFileSelection;
	GtkFileFilter* filter;
	gchar* sChemin;
		
	/* Creation de la fenetre de selection */
	pFileSelection = gtk_file_chooser_dialog_new("Sauvegarder sous...",
			GTK_WINDOW(global->mainWindow),
			GTK_FILE_CHOOSER_ACTION_SAVE,
			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
			GTK_STOCK_SAVE, GTK_RESPONSE_OK,
			NULL);
	/* On limite les actions a cette fenetre */
	gtk_window_set_modal(GTK_WINDOW(pFileSelection), TRUE);
	/* NOTE peut etre pas utile */
	gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(pFileSelection), TRUE);
	/* on se place dans le repertoire save*/
	gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(pFileSelection), "save");
	/* demande de confirmation avant d'ecraser un fichier */
	gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(pFileSelection), TRUE);
	/* on affiche les fichier caches */
	gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(pFileSelection), TRUE);
	
	/*Application d'un filtre pour n'autoriser que le chargement des fichiers .srkrt */
	filter = gtk_file_filter_new ();
	gtk_file_filter_add_pattern (filter, "*.srkrt");
	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(pFileSelection), filter);
				
	/* Affichage fenetre */
	switch(gtk_dialog_run(GTK_DIALOG(pFileSelection)))
	{
		case GTK_RESPONSE_OK:
			/* Recuperation du chemin */
			sChemin = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(pFileSelection));
			fprintf(stderr, "%s", sChemin);
			strcpy(global->save,(char*)sChemin);
			if ( strstr(sChemin, ".srkrt") == NULL ) { /* si le fichier n'a pas d'extension */
				strcat(global->save, ".srkrt");
			} else {
				strcpy(global->save,(char*)sChemin);	
			}
			
			g_free(sChemin);
			break;
		case GTK_RESPONSE_CANCEL:
			gtk_widget_destroy(pFileSelection);
			return;
		default:
			return;
			break;
	}
	gtk_widget_destroy(pFileSelection);
      
	/* chargement de la partie */
	srkrt_save(&(global->game), global->save);
     
}

void disp_gtk_on_load(GtkWidget* widget, Global* global) {
	global->time = 0;
	disp_gtk_load(global);
}

void disp_gtk_on_review(GtkWidget* widget, Global* global) {
	global->time = 2;
	disp_gtk_load(global);
}

void disp_gtk_load(Global* global) {

	GtkWidget* pFileSelection;
	GtkFileFilter* filter;
	gchar* sChemin;
  char tmp[100];
	
	/* Creation de la fenetre de selection */
	pFileSelection = gtk_file_chooser_dialog_new("Ouvrir...",
						      GTK_WINDOW(global->mainWindow),
						      GTK_FILE_CHOOSER_ACTION_OPEN,
						      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
						      GTK_STOCK_OPEN, GTK_RESPONSE_OK,
						      NULL);
	/* On limite les actions a cette fenetre */
	gtk_window_set_modal(GTK_WINDOW(pFileSelection), TRUE);
	gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(pFileSelection), TRUE);
  
  sprintf(tmp, "%s%s", SAVES_PATH, "/save");
	gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(pFileSelection), tmp);
	/* on affiche les fichier caches */
	gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(pFileSelection), TRUE);
	
	/* Application d'un filtre pour n'autoriser que le chargement des fichiers .srkrt */
	filter = gtk_file_filter_new ();
	gtk_file_filter_add_pattern (filter, "*.srkrt");
	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(pFileSelection), filter);
	
	/* Affichage fenetre */
	switch(gtk_dialog_run(GTK_DIALOG(pFileSelection)))
	{
		case GTK_RESPONSE_OK:
			/* Recuperation du chemin */
			sChemin = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(pFileSelection));
			fprintf(stderr, "%s", sChemin);
			strcpy(global->save,(char*)sChemin);
			g_free(sChemin);
			gtk_widget_destroy(pFileSelection);
			break;
		case GTK_RESPONSE_CANCEL:
			gtk_widget_destroy(pFileSelection);
			return;
		default:
			return;
			break;
	}
	
	/* initialisation de l'affichage */
	disp_gtk_reset(global);
	
	/* chargement de la partie */
	srkrt_load(&(global->game), global->save);
	/* creation d'une copie inverse de l'historique pour rejouer les coups */
	(global->s) = stack_create_copy_revert(&(global->game.history));
	/* on joue la partie en jouant un coup tous les global->time secondes, g_timeout_add_seconds permet d'appeller la fonction a chaque fin de timer jusqu'a ce qu'elle renvoie false */
	g_timeout_add_seconds(global->time, ((GSourceFunc)disp_gtk_replay), global);
}

bool disp_gtk_replay(Global* global) {

	/* ecriture de l'historique */
	while ( !stack_is_empty(&(global->s)) ) {
		/* on recupere la tete*/
		global->move = stack_head(&(global->s));
		/* on depile s */
		stack_remove(&(global->s));
		/* on joue le coup move */
		disp_gtk_move(global);
		
		return(TRUE);
	}
	return(FALSE);
}

void disp_gtk_on_about(GtkWidget* widget, gpointer data) {

	GtkWidget* about;

	/* Creation de la boite de message */
	about = gtk_message_dialog_new (GTK_WINDOW(data),
		GTK_DIALOG_MODAL,
		GTK_MESSAGE_INFO,
		GTK_BUTTONS_OK,
		"\nRéalisation : Arnaud Aujon\n"
		"à l'aide de la bibliothèque Gtk+ 2.0\n");
	
	/* Affichage de la boite de message */
	gtk_dialog_run(GTK_DIALOG(about));

	gtk_widget_destroy(about);
}

void disp_gtk_on_rules(GtkWidget* widget, gpointer data) {

	GtkWidget* window;
	const gchar* but = "Le but du jeu est de capturer toutes les pièces de l´adversaire.";
	const gchar* move = "Chaque joueur joue un mouvement, à tour de rôle. Les mouvements sont faits en déplaçant une de ses propres pièces du noeud où elle est placée jusqu´à un noeud adjacents qui soit libre. Le déplacement pourra être fait horizontalement, verticalement ou en diagonale, vers l´avant ou vers l´arrière (comme le roi aux échecs).";
	const gchar* capture = "Pour prendre une pièce adverse, il faut se déplacer en ligne droite, d'autant de cases que l'on souhaite, mais en transitant par au moins un cercle avant d'atteindre la cible. Le pion adverse est retiré et on se met à sa place. Il n'est jamais autorisé de passer au dessus d'un autre pion, ami ou adverse. On peut enchaîner plusieurs sections courbes et droites afin de réaliser une capture. On ne peut pas sauter par dessus d´autres pièces.";

	/* Creation de la boite de message */
	window = gtk_message_dialog_new (GTK_WINDOW(data),
		GTK_DIALOG_MODAL,
		GTK_MESSAGE_INFO,
		GTK_BUTTONS_OK,
		"%s\n\n%s\n\n%s",
		but, move, capture);

	/* Affichage de la boite de message */
	gtk_dialog_run(GTK_DIALOG(window));

	/* Destruction de la boite de dialogue */
	gtk_widget_destroy(window);
}

void disp_gtk_end(Global* global) {
	GtkWidget* quit;
	const gchar* message;
	
	if ( srkrt_ia_result(global->game) == DRAW) {
		message = "Partie nulle !";
	} else if ( srkrt_ia_result(global->game) == PLAYER_1_WON ) {
		message = "Le joueur 1 gagne la partie !";
	} else if ( srkrt_ia_result(global->game) == PLAYER_2_WON ) {
		message = "Le joueur 2 gagne la partie !";
	} else { /*partie encore en cours*/
		return ;
	}
	
	/* creation de la boite de dialogue */
	quit = gtk_message_dialog_new(GTK_WINDOW(global->mainWindow),
					GTK_DIALOG_MODAL,
					GTK_MESSAGE_INFO,
					GTK_BUTTONS_OK,
					message);
				       
	/* Affichage et attente d une reponse */
	gtk_dialog_run(GTK_DIALOG(quit));
	
	gtk_widget_destroy(quit);
}

void disp_gtk_on_quit(GtkWidget* widget, Global* global) {
	
	GtkWidget* Question;

	/* Creation de la boite de message */
	/* Type : Question -> GTK_MESSAGE_QUESTION */
	/* Boutons : 1 OUI, 1 NON -> GTK_BUTTONS_YES_NO */
	Question = gtk_message_dialog_new (GTK_WINDOW(global->mainWindow),
		GTK_DIALOG_MODAL,
		GTK_MESSAGE_QUESTION,
		GTK_BUTTONS_YES_NO,
		"Etes-vous sûr de\nvouloir quitter ?");

	/* Affichage et attente d une reponse */
	switch(gtk_dialog_run(GTK_DIALOG(Question)))
	{
		case GTK_RESPONSE_YES:   
		/* on libere la memoire */
		gtk_widget_destroy(global->imageBoard);
		gtk_widget_destroy(global->imageBackground);
		stack_destroy(&(global->game.history));
		/* on quitte l application */
		gtk_main_quit();
		break;
		case GTK_RESPONSE_NO:
		/* on detruit la boite de message */
		gtk_widget_destroy(Question);
		break;
	}
}

void disp_gtk_on_press_square(GtkWidget* widget, GdkEventButton *event, Global* global) {

	int x,y;
	
	#ifdef SERVER
	if (global->game.toPlay != PLAYER_1) {
		fprintf(stderr, "pas a toi de jouer\n");
		return ;
	}
	#endif
	#ifdef CLIENT
	if (global->game.toPlay != PLAYER_2) {
		fprintf(stderr, "pas a toi de jouer\n");
		return ;
	}
	#endif

	if ( srkrt_ia_result(global->game) == NOT_OVER ) {
		/* on recupère les coordonnées du widget père au GtkWidget widget ( qui est l'eventBox )*/

		
		/*recuperation des coordonnes */
		gtk_widget_get_pointer(gtk_widget_get_ancestor(widget,GTK_TYPE_TABLE), &x, &y);
		
		/* on transforme les coordonnees absolue en relative a la grille */
		x = (x-(gint)50)/(gint)49; /* 50 = décalage de la table par rapport au bord de la fenetre, 49 = taille d'un pion */
		y = (y-(gint)50)/(gint)49; /* idem*/
		fprintf(stderr, "%d %d\n", y, x);

		
			
		
		if ( global->choice == (gint)1 ) {
			global->move = move_create(y,x,0,0, false);
			/* on surligne le pion selectionne */
			disp_gtk_highlight_pawn(global);
			global->choice = (gint)2;
		} else if ( global->choice == (gint)2 ) {
			global->move = move_create(global->move.xi, global->move.yi, y, x, global->game.board[y][x] == (-1) *global->game.toPlay);
			/* on desurligne le pion selectionne */
			disp_gtk_highlight_pawn(global);
			/* si le coup est autorise */
			if ( srkrt_is_allowed(&(global->game), global->move) ) {
				/* le joueur joue */
				disp_gtk_move(global);
				
				/* si c'est une partie contre l'ordinateur, il joue */
				if ( global->game.vs == CPU ) {
					disp_gtk_cpu_play(global);
				}
				#ifdef NETWORK
				/* on envoie le coup */
				ivy_send_move(global);
				#endif
			} else {
				fprintf(stderr, "Warning in disp_gtk_move() : mouvement impossible !\n");
			}
			
			global->choice = 1;
		} else {
			fprintf(stderr, "Error in disp_gtk_on_press_square() : unmatched value %d!\n", global->choice);
		}
	} else { /* si la partie est termine */
		disp_gtk_end(global);
}

}

void disp_gtk_cpu_play(Global* global) {
	
	/* si la partie n'est pas fini*/
	if (srkrt_ia_result(global->game) == NOT_OVER) {
		/* on recupere le mouvement de l'ordinateur */
		global->move=srkrt_ia_bestMove(global->game) ;
		fprintf(stderr, "CPU play %d %d %d %d", global->move.xi, global->move.yi, global->move.xf, global->move.yf);
		disp_gtk_move(global);
	} else {
		disp_gtk_end(global);
	}
}

bool disp_gtk_move(Global* global) {
	
		/* on regarde s'il y a prise */
		if ( global->game.board[global->move.xf][global->move.yf] == (-1)*global->game.toPlay) {
			global->move.capture = true;
		} else {
			global->move.capture = false;
		}
		
		/* on joue le coup */
		srkrt_play(&(global->game), global->move);

		/* on cache l'image a la position d'origine */
		gtk_widget_hide(global->grille[global->move.xi][global->move.yi].image);
		
		/* on affiche le pion sur la case d'arrivée */
		/* on vérifie si la case n'a pas ete initialisé */
		if ( global->grille[global->move.xf][global->move.yf].image != NULL ) {
			/* on change l'image */
			if ( global->game.toPlay == PLAYER_1 ) {
				gtk_image_set_from_file(GTK_IMAGE(global->grille[global->move.xf][global->move.yf].image), global->pawnPlayer2);	
				
			} else {
				gtk_image_set_from_file(GTK_IMAGE(global->grille[global->move.xf][global->move.yf].image), global->pawnPlayer1);
			}
		} else {
			/* on cree l'image */
			if ( global->game.toPlay == PLAYER_1 ) {
				global->grille[global->move.xf][global->move.yf].image = gtk_image_new_from_file(global->pawnPlayer2);	
				
			} else {
				global->grille[global->move.xf][global->move.yf].image = gtk_image_new_from_file(global->pawnPlayer1);
			}
			gtk_container_add (GTK_CONTAINER (global->grille[global->move.xf][global->move.yf].eventBox), global->grille[global->move.xf][global->move.yf].image);
		}
		/* on affiche l'image */
		gtk_widget_show(global->grille[global->move.xf][global->move.yf].image);
		
		return FALSE;
}
